package JavaHomeWork;

import java.util.Random; // 导入随机数生成类
import java.util.Scanner;
// 抽象类 MathProblem，所有年级的数学题目类都继承此类
abstract class MathProblem {
    protected Random random = new Random(); // 随机数生成器，用于生成题目中的数字和运算符

    // 抽象方法
    public abstract String generateProblem();
    // 计算题目的结果
    public abstract int calculateResult(String problem);
}
// 一年级的数学题目类
class GradeOneProblem extends MathProblem {

    private Random random = new Random();
    private String problem;  // 存储生成的题目

    // 生成一年级题目（加法、减法，结果控制在100以内）
    public String generateProblem() {
        int num1 = random.nextInt(100) + 1;  // 第一个数字（1-100）
        int num2 = random.nextInt(100) + 1;  // 第二个数字（1-100）
        String operator = random.nextBoolean() ? "+" : "-";  // 随机选择加法或减法

        // 确保生成的题目结果不超过100且不为负数
        while (true) {
            int result = 0;
            if (operator.equals("+")) {
                result = num1 + num2;
            } else {
                result = num1 - num2;
            }

            // 如果加法或减法结果在100以内且不为负数，则生成题目并返回
            if (result >= 0 && result <= 100) {
                problem = num1 + " " + operator + " " + num2;  // 生成题目并存储
                return problem;  // 返回题目字符串
            } else {
                num1 = random.nextInt(100) + 1;  // 重新生成数字
                num2 = random.nextInt(100) + 1;
                operator = random.nextBoolean() ? "+" : "-";  // 重新选择运算符
            }
        }
    }

    // 生成带括号的题目
    public String generateProblemWithParentheses() {
        int num1 = random.nextInt(100) + 1;
        int num2 = random.nextInt(100) + 1;
        int num3 = random.nextInt(100) + 1;
        String operator1 = random.nextBoolean() ? "+" : "-"; // 第一个运算符
        String operator2 = random.nextBoolean() ? "+" : "-"; // 第二个运算符

        // 确保括号内的结果不会导致负数
        while (true) {
            int result1 = 0, result2 = 0;
            if (operator1.equals("+")) {
                result1 = num1 + num2;
            } else {
                result1 = num1 - num2;
            }
            if (operator2.equals("+")) {
                result2 = result1 + num3;
            } else {
                result2 = result1 - num3;
            }

            // 保证括号内运算结果在0到100之间
            if (result2 >= 0 && result2 <= 100) {
                problem = num1 + " " + operator1 + " " + num2 + " " + operator2 + " (" + num3 + ")";
                return problem;  // 返回包含括号的题目
            } else {
                num1 = random.nextInt(100) + 1;
                num2 = random.nextInt(100) + 1;
                num3 = random.nextInt(100) + 1;
                operator1 = random.nextBoolean() ? "+" : "-";
                operator2 = random.nextBoolean() ? "+" : "-";
            }
        }
    }

    public int calculateResult(String problem) {
        // 分割字符串
        String[] parts = problem.split(" ");

        // 处理 num1 和 num2 时去除括号
        int num1 = Integer.parseInt(parts[0].replace("(", "").replace(")", "").trim());
        String operator1 = parts[1].trim();
        int num2 = Integer.parseInt(parts[2].replace("(", "").replace(")", "").trim());

        // 判断是否存在括号
        if (problem.contains("(")) {
            // 处理 num3 和 operator2
            int num3 = Integer.parseInt(parts[4].replace("(", "").replace(")", "").trim());
            String operator2 = parts[3].trim();

            // 计算结果
            int result1 = operator1.equals("+") ? num1 + num2 : num1 - num2;
            return operator2.equals("+") ? result1 + num3 : result1 - num3;
        }

        // 没有括号时，直接计算
        return operator1.equals("+") ? num1 + num2 : num1 - num2;
    }
    // 生成多道题目并返回
    public String generateMultipleProblems(int count) {
        StringBuilder problems = new StringBuilder();
        for (int i = 0; i < count; i++) {
            // 随机选择是生成普通题目还是带括号的题目
            String problem;
            if (random.nextBoolean()) {
                problem = generateProblem();  // 普通题目
            } else {
                problem = generateProblemWithParentheses();  // 带括号的题目
            }

            int result = calculateResult(problem);
            problems.append(problem).append(" = ").append(result).append("\n");
        }
        return problems.toString();
    }
}
// 二年级的数学题目类
        class GradeTwoProblem extends MathProblem {
    // 随机数生成器
    private Random random = new Random();

    // 生成二年级题目（加法、减法，可以带括号，结果不能为负数）
    @Override
    public String generateProblem() {
        int num1 = random.nextInt(100) + 1; // 随机生成1到100的数字
        int num2 = random.nextInt(100) + 1; // 随机生成1到100的数字
        int num3 = random.nextInt(100) + 1; // 用于括号内部的数字
        String operator1 = random.nextBoolean() ? "+" : "-"; // 随机选择加法或减法运算符
        String operator2 = random.nextBoolean() ? "+" : "-"; // 随机选择加法或减法运算符

        // 生成是否带括号的题目，且括号内运算的结果要符合条件
        boolean hasParentheses = random.nextBoolean();

        String problem;
        int result;

        if (hasParentheses) {
            // 使用括号来包裹第二部分的计算
            if (operator2.equals("+")) {
                result = num1 + (num2 + num3);  // 生成带括号的题目
                problem = num1 + " " + operator1 + " (" + num2 + " " + operator2 + " " + num3 + ")";
            } else {
                result = num1 + (num2 - num3);  // 生成带括号的题目
                problem = num1 + " " + operator1 + " (" + num2 + " " + operator2 + " " + num3 + ")";
            }
        } else {
            // 不使用括号的普通题目
            if (operator1.equals("+")) {
                result = num1 + num2;
                problem = num1 + " " + operator1 + " " + num2;
            } else {
                // 确保减法结果大于0
                while (num1 - num2 <= 0) {
                    num1 = random.nextInt(100) + 1; // 重新生成 num1，确保 num1 > num2
                    num2 = random.nextInt(100) + 1; // 重新生成 num2
                }
                result = num1 - num2;
                problem = num1 + " " + operator1 + " " + num2;
            }
        }

        return problem;
    }

    // 生成多道题目并返回
    public String generateMultipleProblems(int count) {
        StringBuilder problems = new StringBuilder();
        for (int i = 0; i < count; i++) {
            String problem = generateProblem();
            problems.append(problem).append(" = ").append(calculateResult(problem)).append("\n");
        }
        return problems.toString();
    }

    @Override
    public int calculateResult(String problem) {
        // 去除外部括号 (如果有)
        problem = problem.trim();
        if (problem.startsWith("(") && problem.endsWith(")")) {
            problem = problem.substring(1, problem.length() - 1).trim();
        }

        // 如果题目中有括号，需要优先计算括号内部
        if (problem.contains("(")) {
            int startIdx = problem.indexOf('(');
            int endIdx = problem.indexOf(')', startIdx);
            String insideParentheses = problem.substring(startIdx + 1, endIdx);
            int parenthesesResult = calculateResult(insideParentheses);  // 递归计算括号内的部分

            // 替换括号内容为计算结果
            problem = problem.substring(0, startIdx) + parenthesesResult + problem.substring(endIdx + 1);
        }

        // 分割表达式
        String[] parts = problem.split(" ");

        // 确保数组长度足够
        if (parts.length < 3) {
            throw new IllegalArgumentException("输入格式错误，无法解析问题：" + problem);
        }

        // 处理 num1 和 num2 时去除括号
        int num1 = Integer.parseInt(parts[0].trim());
        String operator = parts[1].trim();
        int num2 = Integer.parseInt(parts[2].trim());

        // 计算结果
        if (operator.equals("+")) {
            return num1 + num2;
        } else if (operator.equals("-")) {
            return num1 - num2;
        } else {
            throw new IllegalArgumentException("不支持的运算符：" + operator);
        }
    }
}
 class GradeThreeProblem extends MathProblem {
     private Random random = new Random();

     // 生成题目
     public String generateProblem() {
         int num1=0, num2=0, num3=0;
         String operator1 = getOperator(random.nextInt(4));  // 随机选择第一个运算符
         String operator2 = getOperator(random.nextInt(4));  // 随机选择第二个运算符

         // 确保除法能整除且符合两位数除一位数的规则
         if (operator1.equals("÷")) {
             // 确保 num1 是 num2 的倍数，并且 num1 和 num2 分别在 10-99 和 1-9 之间
             num2 = random.nextInt(9) + 1;  // 1 到 9 的数字
             num1 = (random.nextInt(90) + 10) / num2 * num2;  // 确保 num1 是 num2 的倍数，并且 num1 在 10 到 99 之间
         } else {
             num1 = random.nextInt(90) + 10;  // 10 到 99 的数字
         }

         if (operator2.equals("÷")) {
             // 确保 num3 是 num2 的倍数，并且 num3 和 num2 分别在 10-99 和 1-9 之间
             num2 = random.nextInt(9) + 1;  // 1 到 9 的数字
             num3 = (random.nextInt(90) + 10) / num2 * num2;  // 确保 num3 是 num2 的倍数
         } else {
             num3 = random.nextInt(90) + 10;  // 10 到 99 的数字
         }

         // 确保减法结果不为负数
         if (operator1.equals("-") && num1 < num2) {
             int temp = num1;
             num1 = num2;
             num2 = temp;  // 交换 num1 和 num2，确保减法结果不为负
         }

         if (operator2.equals("-") && num2 < num3) {
             int temp = num2;
             num2 = num3;
             num3 = temp;  // 交换 num2 和 num3，确保减法结果不为负
         }

         // 随机决定是否使用括号
         boolean hasParentheses = random.nextBoolean();
         if (hasParentheses) {
             return "(" + num1 + " " + operator1 + " " + num2 + ")" + " " + operator2 + " " + num3;
         } else {
             return num1 + " " + operator1 + " " + num2 + " " + operator2 + " " + num3;
         }
     }

     // 获取运算符的符号
     private String getOperator(int choice) {
         switch (choice) {
             case 0:
                 return "+";
             case 1:
                 return "-";
             case 2:
                 return "×";
             case 3:
                 return "÷";
             default:
                 return "+";  // 默认返回加法
         }
     }

     // 计算三年级题目的结果
     public int calculateResult(String problem) {
         String[] parts = problem.replaceAll("[()]", "").split(" ");

         int num1 = Integer.parseInt(parts[0]);
         int num2 = Integer.parseInt(parts[2]);
         int num3 = Integer.parseInt(parts[4]);
         String operator1 = parts[1];
         String operator2 = parts[3];

         // 处理是否包含括号
         if (problem.contains("(") && problem.contains(")")) {
             // 如果包含括号，先计算括号内的部分
             int result1 = calculateIntermediateResult(num1, num2, operator1);
             return calculateIntermediateResult(result1, num3, operator2); // 计算最终结果
         } else {
             // 如果没有括号，直接按顺序计算
             int result1 = calculateIntermediateResult(num1, num2, operator1);
             return calculateIntermediateResult(result1, num3, operator2); // 返回最终结果
         }
     }

     // 计算中间结果
     private int calculateIntermediateResult(int num1, int num2, String operator) {
         switch (operator) {
             case "+":
                 return num1 + num2;
             case "-":
                 return num1 - num2;
             case "×":
                 return num1 * num2;
             case "÷":
                 // 确保除法能够整除
                 if (num2 == 0) {
                     throw new ArithmeticException("除数不能为零");
                 }
                 return num1 / num2;  // 假设除法能整除
             default:
                 return 0;
         }
     }

     // 生成指定数量的题目和答案
     public void generateProblemsAndAnswers(int numberOfProblems) {
         for (int i = 0; i < numberOfProblems; i++) {
             String problem = generateProblem();
             int result = calculateResult(problem);
             System.out.println("题目: " + problem + " = " + result);
         }
     }
 }
            public class test {
                public static void main(String[] args) {
                    Scanner scanner = new Scanner(System.in);
                    MathProblem problem = null;

                    while (true) {
                        // 打印菜单选项
                        System.out.println("请选择年级：");
                        System.out.println("1. 一年级");
                        System.out.println("2. 二年级");
                        System.out.println("3. 三年级");
                        System.out.println("4. 退出");

                        String choice = scanner.nextLine();

                        if (choice.equals("4")) {
                            // 退出程序
                            System.out.println("退出程序...");
                            break;
                        }

                        // 根据选择的年级，创建相应的题目类对象
                        switch (choice) {
                            case "1":
                                problem = new GradeOneProblem();
                                break;
                            case "2":
                                problem = new GradeTwoProblem();
                                break;
                            case "3":
                                problem = new GradeThreeProblem();
                                break;
                            default:
                                System.out.println("无效选择，请重新输入。");
                                continue;
                        }

                        // 提示用户输入生成题目的数量
                        System.out.println("请输入题目的数量：");
                        int count = 0;
                        try {
                            count = Integer.parseInt(scanner.nextLine());
                        } catch (NumberFormatException e) {
                            System.out.println("无效的数字，请重新输入。");
                            continue;
                        }

                        // 根据选择的年级生成题目和答案
                        if (problem != null) {
                            String result = "";
                            if (problem instanceof GradeOneProblem) {
                                result = ((GradeOneProblem) problem).generateMultipleProblems(count);
                            } else if (problem instanceof GradeTwoProblem) {
                                result = ((GradeTwoProblem) problem).generateMultipleProblems(count);
                            } else if (problem instanceof GradeThreeProblem) {
                                ((GradeThreeProblem) problem).generateProblemsAndAnswers(count);
                                continue; // 三年级题目会直接输出答案
                            }

                            // 输出生成的题目和答案
                            System.out.println("生成的题目和答案：");
                            System.out.println(result);
                        }
                    }

                    scanner.close();
                }
            }


